<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
                      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
    <title>Plugins - Zend Framework Manual</title>

    <link href="../css/shCore.css" rel="stylesheet" type="text/css" />
    <link href="../css/shThemeDefault.css" rel="stylesheet" type="text/css" />
    <link href="../css/styles.css" media="all" rel="stylesheet" type="text/css" />
</head>
<body>
<h1>Zend Framework</h1>
<h2>Programmer's Reference Guide</h2>
<ul>
    <li><a href="../en/zend.controller.plugins.html">Inglês (English)</a></li>
    <li><a href="../pt-br/zend.controller.plugins.html">Português Brasileiro (Brazilian Portuguese)</a></li>
</ul>
<table width="100%">
    <tr valign="top">
        <td width="85%">
            <table width="100%">
                <tr>
                    <td width="25%" style="text-align: left;">
                    <a href="zend.controller.response.html">The Response Object</a>
                    </td>

                    <td width="50%" style="text-align: center;">
                        <div class="up"><span class="up"><a href="zend.controller.html">Zend_Controller</a></span><br />
                        <span class="home"><a href="manual.html">Programmer's Reference Guide</a></span></div>
                    </td>

                    <td width="25%" style="text-align: right;">
                        <div class="next" style="text-align: right; float: right;"><a href="zend.controller.modular.html">Using a Conventional Modular Directory Structure</a></div>
                    </td>
                </tr>
            </table>
<hr />
<div id="zend.controller.plugins" class="section"><div class="info"><h1 class="title">Plugins</h1></div>
    

    <div class="section" id="zend.controller.plugins.introduction"><div class="info"><h1 class="title">Introduction</h1></div>
        

        <p class="para">
            The controller architecture includes a plugin system that allows
            user code to be called when certain events occur in the controller
            process lifetime. The front controller uses a plugin broker as a
            registry for user plugins, and the plugin broker ensures that event
            methods are called on each plugin registered with the front
            controller.
        </p>

        <p class="para">
            The event methods are defined in the abstract class
            <span class="classname">Zend_Controller_Plugin_Abstract</span>, from which user plugin
            classes inherit:
        </p>

        <ul class="itemizedlist">
            <li class="listitem">
                <p class="para">
                     <span class="methodname">routeStartup()</span> is called before
                    <span class="classname">Zend_Controller_Front</span> calls on <a href="zend.controller.router.html" class="link">the router</a>
                    to evaluate the request against the registered routes.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                     <span class="methodname">routeShutdown()</span> is called after <a href="zend.controller.router.html" class="link">the router</a>
                    finishes routing the request.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                     <span class="methodname">dispatchLoopStartup()</span> is called before
                    <span class="classname">Zend_Controller_Front</span> enters its dispatch loop.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                     <span class="methodname">preDispatch()</span> is called before an action is
                    dispatched by <a href="zend.controller.dispatcher.html" class="link">the
                        dispatcher</a>. This callback allows for proxy or
                    filter behavior. By altering the request and resetting its
                    dispatched flag (via
                     <span class="methodname">Zend_Controller_Request_Abstract::setDispatched(false)</span>),
                    the current action may be skipped and/or replaced.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                     <span class="methodname">postDispatch()</span> is called after an action is
                    dispatched by <a href="zend.controller.dispatcher.html" class="link">the
                        dispatcher</a>. This callback allows for proxy or
                    filter behavior. By altering the request and resetting its
                    dispatched flag (via
                     <span class="methodname">Zend_Controller_Request_Abstract::setDispatched(false)</span>),
                    a new action may be specified for dispatching.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                     <span class="methodname">dispatchLoopShutdown()</span> is called after
                    <span class="classname">Zend_Controller_Front</span> exits its dispatch loop.
                </p>
            </li>
        </ul>
    </div>

    <div class="section" id="zend.controller.plugins.writing"><div class="info"><h1 class="title">Writing Plugins</h1></div>
        

        <p class="para">
            In order to write a plugin class, simply include and extend the
            abstract class <span class="classname">Zend_Controller_Plugin_Abstract</span>:
        </p>

        <pre class="programlisting brush: php">
class MyPlugin extends Zend_Controller_Plugin_Abstract
{
    // ...
}
</pre>


        <p class="para">
            None of the methods of <span class="classname">Zend_Controller_Plugin_Abstract</span>
            are abstract, and this means that plugin classes are not forced to
            implement any of the available event methods listed above. Plugin
            writers may implement only those methods required by their
            particular needs.
        </p>

        <p class="para">
            <span class="classname">Zend_Controller_Plugin_Abstract</span> also makes the request
            and response objects available to controller plugins via the
             <span class="methodname">getRequest()</span> and  <span class="methodname">getResponse()</span>
            methods, respectively.
        </p>
    </div>

    <div class="section" id="zend.controller.plugins.using"><div class="info"><h1 class="title">Using Plugins</h1></div>
        

        <p class="para">
            Plugin classes are registered with
             <span class="methodname">Zend_Controller_Front::registerPlugin()</span>, and may be
            registered at any time. The following snippet illustrates how a
            plugin may be used in the controller chain:
        </p>

        <pre class="programlisting brush: php">
class MyPlugin extends Zend_Controller_Plugin_Abstract
{
    public function routeStartup(Zend_Controller_Request_Abstract $request)
    {
        $this-&gt;getResponse()
             -&gt;appendBody(&quot;&lt;p&gt;routeStartup() called&lt;/p&gt;\n&quot;);
    }

    public function routeShutdown(Zend_Controller_Request_Abstract $request)
    {
        $this-&gt;getResponse()
             -&gt;appendBody(&quot;&lt;p&gt;routeShutdown() called&lt;/p&gt;\n&quot;);
    }

    public function dispatchLoopStartup(
        Zend_Controller_Request_Abstract $request)
    {
        $this-&gt;getResponse()
             -&gt;appendBody(&quot;&lt;p&gt;dispatchLoopStartup() called&lt;/p&gt;\n&quot;);
    }

    public function preDispatch(Zend_Controller_Request_Abstract $request)
    {
        $this-&gt;getResponse()
             -&gt;appendBody(&quot;&lt;p&gt;preDispatch() called&lt;/p&gt;\n&quot;);
    }

    public function postDispatch(Zend_Controller_Request_Abstract $request)
    {
        $this-&gt;getResponse()
             -&gt;appendBody(&quot;&lt;p&gt;postDispatch() called&lt;/p&gt;\n&quot;);
    }

    public function dispatchLoopShutdown()
    {
        $this-&gt;getResponse()
             -&gt;appendBody(&quot;&lt;p&gt;dispatchLoopShutdown() called&lt;/p&gt;\n&quot;);
    }
}

$front = Zend_Controller_Front::getInstance();
$front-&gt;setControllerDirectory(&#039;/path/to/controllers&#039;)
      -&gt;setRouter(new Zend_Controller_Router_Rewrite())
      -&gt;registerPlugin(new MyPlugin());
$front-&gt;dispatch();
</pre>


        <p class="para">
            Assuming that no actions called emit any output, and only one action
            is called, the functionality of the above plugin would still create
            the following output:
        </p>

        <pre class="programlisting brush: php">
&lt;p&gt;routeStartup() called&lt;/p&gt;
&lt;p&gt;routeShutdown() called&lt;/p&gt;
&lt;p&gt;dispatchLoopStartup() called&lt;/p&gt;
&lt;p&gt;preDispatch() called&lt;/p&gt;
&lt;p&gt;postDispatch() called&lt;/p&gt;
&lt;p&gt;dispatchLoopShutdown() called&lt;/p&gt;
</pre>


        <blockquote class="note"><p><b class="note">Note</b>: 
            <p class="para">
                Plugins may be registered at any time during the front
                controller execution. However, if an event has passed for which
                the plugin has a registered event method, that method will not
                be triggered.
            </p>
        </p></blockquote>
    </div>

    <div class="section" id="zend.controller.plugins.manipulating"><div class="info"><h1 class="title">Retrieving and Manipulating Plugins</h1></div>
        

        <p class="para">
            On occasion, you may need to unregister or retrieve a plugin. The
            following methods of the front controller allow you to do so:
        </p>

        <ul class="itemizedlist">
            <li class="listitem">
                <p class="para">
                     <span class="methodname">getPlugin($class)</span> allows you to retrieve a
                    plugin by class name. If no plugins match, it returns
                    <b><tt>FALSE</tt></b>. If more than one plugin of that class
                    is registered, it returns an array.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                     <span class="methodname">getPlugins()</span> retrieves the entire plugin stack.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                     <span class="methodname">unregisterPlugin($plugin)</span> allows you to remove
                    a plugin from the stack. You may pass a plugin object, or
                    the class name of the plugin you wish to unregister. If you
                    pass the class name, any plugins of that class will be
                    removed.
                </p>
            </li>
        </ul>
    </div>

    <div class="section" id="zend.controller.plugins.standard"><div class="info"><h1 class="title">Plugins Included in the Standard Distribution</h1></div>
        

        <p class="para">
            Zend Framework includes a plugin for error handling in its standard
            distribution.
        </p>

        <div class="section" id="zend.controller.plugins.standard.actionstack"><div class="info"><h1 class="title">ActionStack</h1></div>
    

    <p class="para">
        The <em class="emphasis">ActionStack</em> plugin allows you to manage a stack of
        requests, and operates as a <em class="emphasis">postDispatch</em> plugin. If a
        forward (i.e., a call to another action) is already detected in the
        current request object, it does nothing. However, if not, it checks its
        stack and pulls the topmost item off it and forwards to the action
        specified in that request. The stack is processed in <acronym class="acronym">LIFO</acronym> order.
    </p>

    <p class="para">
        You can retrieve the plugin from the front controller at any time using
         <span class="methodname">Zend_Controller_Front::getPlugin(&#039;Zend_Controller_Plugin_ActionStack&#039;)</span>.
        Once you have the plugin object, there are a variety of mechanisms you
        can use to manipulate it.
    </p>

    <ul class="itemizedlist">
        <li class="listitem">
            <p class="para">
                 <span class="methodname">getRegistry()</span> and  <span class="methodname">setRegistry()</span>.
                Internally, <em class="emphasis">ActionStack</em> uses a
                <span class="classname">Zend_Registry</span> instance to store the stack. You can
                substitute a different registry instance or retrieve it with
                these accessors.
            </p>
        </li>

        <li class="listitem">
            <p class="para">
                 <span class="methodname">getRegistryKey()</span> and
                 <span class="methodname">setRegistryKey()</span>.
                These can be used to indicate which registry key to use when
                pulling the stack. Default value is
                &#039;<span class="classname">Zend_Controller_Plugin_ActionStack</span>&#039;.
            </p>
        </li>

        <li class="listitem">
            <p class="para">
                 <span class="methodname">getStack()</span> allows you to retrieve the stack of
                actions in its entirety.
            </p>
        </li>

        <li class="listitem">
            <p class="para">
                 <span class="methodname">pushStack()</span> and  <span class="methodname">popStack()</span> allow
                you to add to and pull from the stack, respectively.
                 <span class="methodname">pushStack()</span> accepts a request object.
            </p>
        </li>
    </ul>

    <p class="para">
        An additional method,  <span class="methodname">forward()</span>, expects a request object,
        and sets the state of the current request object in the front controller
        to the state of the provided request object, and markes it as
        undispatched (forcing another iteration of the dispatch loop).
    </p>
</div>
        <div class="section" id="zend.controller.plugins.standard.errorhandler"><div class="info"><h1 class="title">Zend_Controller_Plugin_ErrorHandler</h1></div>
    

    <p class="para">
        <span class="classname">Zend_Controller_Plugin_ErrorHandler</span> provides a drop-in
        plugin for handling exceptions thrown by your application, including
        those resulting from missing controllers or actions; it is an
        alternative to the methods listed in the <a href="zend.controller.exceptions.html" class="link">MVC Exceptions section</a>.
    </p>

    <p class="para">
        The primary targets of the plugin are:
    </p>

    <ul class="itemizedlist">
        <li class="listitem">
            <p class="para">Intercept exceptions raised when no route matched</p>
        </li>

        <li class="listitem">
            <p class="para">Intercept exceptions raised due to missing controllers or action methods</p>
        </li>

        <li class="listitem">
            <p class="para">Intercept exceptions raised within action controllers</p>
        </li>
    </ul>

    <p class="para">
        In other words, the <em class="emphasis">ErrorHandler</em> plugin is designed to
        handle <acronym class="acronym">HTTP</acronym> 404-type errors (page missing) and 500-type errors (internal
        error). It is not intended to catch exceptions raised in other plugins.
    </p>

    <p class="para">
        By default, <span class="classname">Zend_Controller_Plugin_ErrorHandler</span> will
        forward to  <span class="methodname">ErrorController::errorAction()</span> in the default
        module. You may set alternate values for these by using the various
        accessors available to the plugin:
    </p>

    <ul class="itemizedlist">
        <li class="listitem">
            <p class="para">
                 <span class="methodname">setErrorHandlerModule()</span> sets the controller module to use.
            </p>
        </li>

        <li class="listitem">
            <p class="para">
                 <span class="methodname">setErrorHandlerController()</span> sets the controller to use.
            </p>
        </li>

        <li class="listitem">
            <p class="para">
                 <span class="methodname">setErrorHandlerAction()</span> sets the controller action to use.
            </p>
        </li>

        <li class="listitem">
            <p class="para">
                 <span class="methodname">setErrorHandler()</span> takes an associative array, which
                may contain any of the keys &#039;module&#039;, &#039;controller&#039;, or &#039;action&#039;,
                with which it will set the appropriate values.
            </p>
        </li>
    </ul>

    <p class="para">
        Additionally, you may pass an optional associative array to the
        constructor, which will then proxy to  <span class="methodname">setErrorHandler()</span>.
    </p>

    <p class="para">
        <span class="classname">Zend_Controller_Plugin_ErrorHandler</span> registers a
         <span class="methodname">postDispatch()</span> hook and checks for exceptions registered in
        <a href="zend.controller.response.html" class="link">the response object</a>. If
        any are found, it attempts to forward to the registered error handler
        action.
    </p>

    <p class="para">
        If an exception occurs dispatching the error handler, the plugin will
        tell the front controller to throw exceptions, and rethrow the last
        exception registered with the response object.
    </p>

    <div class="section" id="zend.controller.plugins.standard.errorhandler.fourohfour"><div class="info"><h1 class="title">Using the ErrorHandler as a 404 Handler</h1></div>
        

        <p class="para">
            Since the <em class="emphasis">ErrorHandler</em> plugin captures not only
            application errors, but also errors in the controller chain arising
            from missing controller classes and/or action methods, it can be
            used as a 404 handler. To do so, you will need to have your error
            controller check the exception type.
        </p>

        <p class="para">
            Exceptions captured are logged in an object registered in the
            request. To retrieve it, use
             <span class="methodname">Zend_Controller_Action::_getParam(&#039;error_handler&#039;)</span>:
        </p>

        <pre class="programlisting brush: php">
class ErrorController extends Zend_Controller_Action
{
    public function errorAction()
    {
        $errors = $this-&gt;_getParam(&#039;error_handler&#039;);
    }
}
</pre>


        <p class="para">
            Once you have the error object, you can get the type via
            <strong class="command">$errors-&gt;type;</strong>. It will be one of the following:
        </p>

        <ul class="itemizedlist">
            <li class="listitem">
                <p class="para">
                    <b><tt>Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE</tt></b>,
                    indicating no route matched.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                    <b><tt>Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER</tt></b>,
                    indicating the controller was not found.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                    <b><tt>Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION</tt></b>,
                    indicating the requested action was not found.
                </p>
            </li>

            <li class="listitem">
                <p class="para">
                    <b><tt>Zend_Controller_Plugin_ErrorHandler::EXCEPTION_OTHER</tt></b>,
                    indicating other exceptions.
                </p>
            </li>
        </ul>

        <p class="para">
            You can then test for either of the first three types, and, if so,
            indicate a 404 page:
        </p>

        <pre class="programlisting brush: php">
class ErrorController extends Zend_Controller_Action
{
    public function errorAction()
    {
        $errors = $this-&gt;_getParam(&#039;error_handler&#039;);

        switch ($errors-&gt;type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
                // 404 error -- controller or action not found
                $this-&gt;getResponse()
                     -&gt;setRawHeader(&#039;HTTP/1.1 404 Not Found&#039;);

                // ... get some output to display...
                break;
            default:
                // application error; display error page, but don&#039;t
                // change status code
                break;
        }
    }
}
</pre>


        <p class="para">
            Finally, you can retrieve the exception that triggered the error
            handler by grabbing the <span class="property">exception</span> property of the
            <em class="emphasis">error_handler</em> object:
        </p>

        <pre class="programlisting brush: php">
public function errorAction()
{
        $errors = $this-&gt;_getParam(&#039;error_handler&#039;);

        switch ($errors-&gt;type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
                // 404 error -- controller or action not found
                $this-&gt;getResponse()
                     -&gt;setRawHeader(&#039;HTTP/1.1 404 Not Found&#039;);

                // ... get some output to display...
                break;
            default:
                // application error; display error page, but don&#039;t change
                // status code

                // ...

                // Log the exception:
                $exception = $errors-&gt;exception;
                $log = new Zend_Log(
                    new Zend_Log_Writer_Stream(
                        &#039;/tmp/applicationException.log&#039;
                    )
                );
                $log-&gt;debug($exception-&gt;getMessage() . &quot;\n&quot; .
                            $exception-&gt;getTraceAsString());
                break;
        }
}
</pre>

    </div>

    <div class="section" id="zend.controller.plugins.standard.errorhandler.buffer"><div class="info"><h1 class="title">Handling Previously Rendered Output</h1></div>
        

        <p class="para">
            If you dispatch multiple actions in a request, or if your action
            makes multiple calls to  <span class="methodname">render()</span>, it&#039;s possible that the
            response object already has content stored within it. This can lead
            to rendering a mixture of expected content and error content.
        </p>

        <p class="para">
            If you wish to render errors inline in such pages, no changes will
            be necessary. If you do not wish to render such content, you should
            clear the response body prior to rendering any views:
        </p>

        <pre class="programlisting brush: php">
$this-&gt;getResponse()-&gt;clearBody();
</pre>

    </div>

    <div class="section" id="zend.controller.plugins.standard.errorhandler.examples"><div class="info"><h1 class="title">Plugin Usage Examples</h1></div>
        

        <div class="example" id="zend.controller.plugins.standard.errorhandler.examples.example-1"><div class="info"><p><b>Example #1 Standard Usage</b></p></div>
            

            <pre class="programlisting brush: php">
$front = Zend_Controller_Front::getInstance();
$front-&gt;registerPlugin(new Zend_Controller_Plugin_ErrorHandler());
</pre>

        </div>

        <div class="example" id="zend.controller.plugins.standard.errorhandler.examples.example-2"><div class="info"><p><b>Example #2 Setting a Different Error Handler</b></p></div>
            

            <pre class="programlisting brush: php">
$front = Zend_Controller_Front::getInstance();
$front-&gt;registerPlugin(new Zend_Controller_Plugin_ErrorHandler(array(
    &#039;module&#039;     =&gt; &#039;mystuff&#039;,
    &#039;controller&#039; =&gt; &#039;static&#039;,
    &#039;action&#039;     =&gt; &#039;error&#039;
)));
</pre>

        </div>

        <div class="example" id="zend.controller.plugins.standard.errorhandler.examples.example-3"><div class="info"><p><b>Example #3 Using Accessors</b></p></div>
            

            <pre class="programlisting brush: php">
$plugin = new Zend_Controller_Plugin_ErrorHandler();
$plugin-&gt;setErrorHandlerModule(&#039;mystuff&#039;)
       -&gt;setErrorHandlerController(&#039;static&#039;)
       -&gt;setErrorHandlerAction(&#039;error&#039;);

$front = Zend_Controller_Front::getInstance();
$front-&gt;registerPlugin($plugin);
</pre>

        </div>
    </div>

    <div class="section" id="zend.controller.plugins.standard.errorhandler.controllerexamples"><div class="info"><h1 class="title">Error Controller Example</h1></div>
        

        <p class="para">
            In order to use the Error Handler plugin, you need an error
            controller. Below is a simple example.
        </p>

        <pre class="programlisting brush: php">
class ErrorController extends Zend_Controller_Action
{
    public function errorAction()
    {
        $errors = $this-&gt;_getParam(&#039;error_handler&#039;);

        switch ($errors-&gt;type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
                // 404 error -- controller or action not found
                $this-&gt;getResponse()-&gt;setRawHeader(&#039;HTTP/1.1 404 Not Found&#039;);

                $content =&lt;&lt;&lt;EOH
&lt;h1&gt;Error!&lt;/h1&gt;
&lt;p&gt;The page you requested was not found.&lt;/p&gt;
EOH;
                break;
            default:
                // application error
                $content =&lt;&lt;&lt;EOH
&lt;h1&gt;Error!&lt;/h1&gt;
&lt;p&gt;An unexpected error occurred. Please try again later.&lt;/p&gt;
EOH;
                break;
        }

        // Clear previous content
        $this-&gt;getResponse()-&gt;clearBody();

        $this-&gt;view-&gt;content = $content;
    }
}
</pre>

    </div>
</div>
        <div class="section" id="zend.controller.plugins.standard.puthandler"><div class="info"><h1 class="title">Zend_Controller_Plugin_PutHandler</h1></div>
    

    <p class="para">
        <span class="classname">Zend_Controller_Plugin_PutHandler</span> provides a drop-in
        plugin for marshalling <b><tt>PUT</tt></b> request bodies into request parameters, just
        like <b><tt>POST</tt></b> request bodies. It will inspect the request and, if
        <b><tt>PUT</tt></b>, will use parse_str to parse the raw <b><tt>PUT</tt></b> body
        into an array of params which is then set on the request. E.g.,
    </p>

    <pre class="programlisting brush: txt">
PUT /notes/5.xml HTTP/1.1

title=Hello&amp;body=World
</pre>


    <p class="para">
        To receive the &#039;title&#039; and &#039;body&#039; params as regular request params,
        register the plugin:
    </p>

    <pre class="programlisting brush: php">
$front = Zend_Controller_Front::getInstance();
$front-&gt;registerPlugin(new Zend_Controller_Plugin_PutHandler());
</pre>


    <p class="para">
        Then you can access the <b><tt>PUT</tt></b> body params by name from the request inside
        your controller:
    </p>

    <pre class="programlisting brush: php">
...
public function putAction()
{
    $title = $this-&gt;getRequest()-&gt;getParam(&#039;title&#039;); // $title = &quot;Hello&quot;
    $body = $this-&gt;getRequest()-&gt;getParam(&#039;body&#039;); // $body = &quot;World&quot;
}
...
</pre>

</div>
    </div>
</div>
        <hr />

            <table width="100%">
                <tr>
                    <td width="25%" style="text-align: left;">
                    <a href="zend.controller.response.html">The Response Object</a>
                    </td>

                    <td width="50%" style="text-align: center;">
                        <div class="up"><span class="up"><a href="zend.controller.html">Zend_Controller</a></span><br />
                        <span class="home"><a href="manual.html">Programmer's Reference Guide</a></span></div>
                    </td>

                    <td width="25%" style="text-align: right;">
                        <div class="next" style="text-align: right; float: right;"><a href="zend.controller.modular.html">Using a Conventional Modular Directory Structure</a></div>
                    </td>
                </tr>
            </table>
</td>
        <td style="font-size: smaller;" width="15%"> <style type="text/css">
#leftbar {
	float: left;
	width: 186px;
	padding: 5px;
	font-size: smaller;
}
ul.toc {
	margin: 0px 5px 5px 5px;
	padding: 0px;
}
ul.toc li {
	font-size: 85%;
	margin: 1px 0 1px 1px;
	padding: 1px 0 1px 11px;
	list-style-type: none;
	background-repeat: no-repeat;
	background-position: center left;
}
ul.toc li.header {
	font-size: 115%;
	padding: 5px 0px 5px 11px;
	border-bottom: 1px solid #cccccc;
	margin-bottom: 5px;
}
ul.toc li.active {
	font-weight: bold;
}
ul.toc li a {
	text-decoration: none;
}
ul.toc li a:hover {
	text-decoration: underline;
}
</style>
 <ul class="toc">
  <li class="header home"><a href="manual.html">Programmer's Reference Guide</a></li>
  <li class="header up"><a href="manual.html">Programmer's Reference Guide</a></li>
  <li class="header up"><a href="reference.html">Zend Framework Reference</a></li>
  <li class="header up"><a href="zend.controller.html">Zend_Controller</a></li>
  <li><a href="zend.controller.quickstart.html">Zend_Controller Quick Start</a></li>
  <li><a href="zend.controller.basics.html">Zend_Controller Basics</a></li>
  <li><a href="zend.controller.front.html">The Front Controller</a></li>
  <li><a href="zend.controller.request.html">The Request Object</a></li>
  <li><a href="zend.controller.router.html">The Standard Router</a></li>
  <li><a href="zend.controller.dispatcher.html">The Dispatcher</a></li>
  <li><a href="zend.controller.action.html">Action Controllers</a></li>
  <li><a href="zend.controller.actionhelpers.html">Action Helpers</a></li>
  <li><a href="zend.controller.response.html">The Response Object</a></li>
  <li class="active"><a href="zend.controller.plugins.html">Plugins</a></li>
  <li><a href="zend.controller.modular.html">Using a Conventional Modular Directory Structure</a></li>
  <li><a href="zend.controller.exceptions.html">MVC Exceptions</a></li>
 </ul>
 </td>
    </tr>
</table>

<script type="text/javascript" src="../js/shCore.js"></script>
<script type="text/javascript" src="../js/shAutoloader.js"></script>
<script type="text/javascript" src="../js/main.js"></script>

</body>
</html>